/*河南星辰软件科技有限公司
@copyright Copyright (c) 2010~2022 All rights reserved.
*/
package cn.javaxc.mes.action.product;
import java.io.*;
import java.util.*;
import java.sql.*;
import cn.javaxc.model.base.SQL;
import cn.javaxc.model.base.SQLList;
import cn.javaxc.model.base.SQLMap;
import cn.javaxc.model.base.SQLParam;
import cn.javaxc.model.page.BatisPage;
import cn.javaxc.mvcwork.controller.web.TreeBean;
import cn.javaxc.mvcwork.util.common.CommonUtil;
import cn.javaxc.mvcwork.util.common.MapListUtil;
import cn.javaxc.mvcwork.util.helper.FrameHelper;
import cn.javaxc.mvcwork.util.helper.TreeTableHelper;
import org.springframework.beans.factory.annotation.Autowired;
import cn.javaxc.mvcwork.controller.GenericValidator;
import cn.javaxc.mvcwork.controller.AppUtils;
import cn.javaxc.system.action.base.BaseAction;
import cn.javaxc.talent.util.data.PdfUtil;
import cn.javaxc.talent.util.common.*;
import cn.javaxc.mes.mapper.product.ProcedureMapper;
public class ProcedureAction extends BaseAction
{
    @Autowired(required=false)
	private ProcedureMapper mapper;
    /**
    工序统计图
    */
    
    public Map cartogramProcedure() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        result.put("s_search", pagination.getSearchParas());
        
        
        params.def("CMID7",-1);
        SQLList<SQLMap> s_person=mapper.s_person(params);
        result.put("s_person", s_person);
        
        
        tb = createTreeBean("l_firm_treecols");
        SQLList<SQLMap> l_firm=mapper.l_firm(params);
        l_firm = l_firm.buildTree(tb,tb.getPid());
        result.put("l_firm", l_firm);
        
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        SQLList<SQLMap> parent=mapper.parent(params);
        SQLMap parent_emt=parent.getExistfirst();
        result.put("parent", parent_emt);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        SQLList<SQLMap> all=mapper.all(params);
        result.put("all", all);
        
        
        
        return result;
    }
    /**
    */
    
    public Object s_pro() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> p_pro=mapper.p_pro(params,pagination);
        p_pro.setPagedListInfo(pagination);
        result.put("p_pro", p_pro);
        
        return p_pro;
    }
    /**
    饼状统计图
    */
    
    public Map procedurePancake() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> all=mapper.all(params);
        result.put("all", all);
        
        
        SQLList<SQLMap> s_c=mapper.s_c(params);
        result.put("s_c", s_c);
        
        return result;
    }
    /**
    选择标准文件测试
    */
    
    public Map standardDocumentTest() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        result.put("s_search", pagination.getSearchParas());
        
        
        SQLList<SQLMap> s_files=mapper.s_files(params,pagination);
        s_files.setPagedListInfo(pagination);
        result.put("s_files", s_files);
        
        return result;
    }
    /**
    产品公司部门人员公用页
    */
    
    public Map procedurePerson() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        params.def("CMID7",-1);
        SQLList<SQLMap> s_person=mapper.s_person(params);
        result.put("s_person", s_person);
        
        
        tb = createTreeBean("l_firm_treecols");
        SQLList<SQLMap> l_firm=mapper.l_firm(params);
        l_firm = l_firm.buildTree(tb,tb.getPid());
        result.put("l_firm", l_firm);
        
        return result;
    }
    /**
    基本信息
    */
    
    public Map productProDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> process_info=mapper.process_info(params);
        SQLMap process_info_emt=process_info.getExistfirst();
        result.put("process_info", process_info_emt);
        
        
        SQLList<SQLMap> person_list=mapper.person_list(params);
        result.put("person_list", person_list);
        
        
        SQLList<SQLMap> lp=mapper.lp(params);
        result.put("lp", lp);
        
        return result;
    }
    /**
    修改信息
    */
    
    public Map productProDetUp() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        SQLList<SQLMap> s_nature=mapper.s_nature(params);
        s_nature.setSelectNone("选择性质");
        result.put("s_nature", s_nature);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        SQLList<SQLMap> tech=mapper.tech(params);
        SQLMap tech_emt=tech.getExistfirst();
        result.put("tech", tech_emt);
        
        
        SQLList<SQLMap> lp=mapper.lp(params);
        result.put("lp", lp);
        
        
        
        
        
        
        SQLList<SQLMap> person_list=mapper.person_list(params);
        result.put("person_list", person_list);
        
        return result;
    }
    /**
    操作人员
    */
    
    public Map productProOper() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_user=mapper.s_user(params);
        result.put("s_user", s_user);
        
        return result;
    }
    /**
    增加操作人员
    */
    
    public Map productProOperAdd() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        
        
        SQLList<SQLMap> p_person=mapper.p_person(params,pagination);
        p_person.setPagedListInfo(pagination);
        result.put("p_person", p_person);
        
        
        tb = createTreeBean("l_firm_treecols");
        SQLList<SQLMap> l_firm=mapper.l_firm(params);
        l_firm = l_firm.buildTree(tb,tb.getPid());
        result.put("l_firm", l_firm);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    修改
    */
    
    public Map productProOperUp() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_pro=mapper.t_pro(params);
        SQLMap t_pro_emt=t_pro.getExistfirst();
        result.put("t_pro", t_pro_emt);
        
        return result;
    }
    /**
    生产设备
    */
    
    public Map productProDev() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce_info=mapper.produce_info(params,pagination);
        produce_info.setPagedListInfo(pagination);
        result.put("produce_info", produce_info);
        
        return result;
    }
    /**
    选择生产设备
    */
    
    public Map productProDevChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce_info=mapper.produce_info(params,pagination);
        produce_info.setPagedListInfo(pagination);
        result.put("produce_info", produce_info);
        
        
        SQLList<SQLMap> s_pd=mapper.s_pd(params);
        result.put("s_pd", s_pd);
        
        return result;
    }
    /**
    检测设备
    */
    
    public Map testingEquipmentProce() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce_info=mapper.produce_info(params,pagination);
        produce_info.setPagedListInfo(pagination);
        result.put("produce_info", produce_info);
        
        return result;
    }
    /**
    选择检验设备
    */
    
    public Map choiceTestingEquipment() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce_info=mapper.produce_info(params,pagination);
        produce_info.setPagedListInfo(pagination);
        result.put("produce_info", produce_info);
        
        
        SQLList<SQLMap> s_pd=mapper.s_pd(params);
        result.put("s_pd", s_pd);
        
        return result;
    }
    /**
    选择检验设备备份
    */
    
    public Map choiceEquipmentBackups() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce_info=mapper.produce_info(params,pagination);
        produce_info.setPagedListInfo(pagination);
        result.put("produce_info", produce_info);
        
        
        SQLList<SQLMap> s_pd=mapper.s_pd(params);
        result.put("s_pd", s_pd);
        
        return result;
    }
    /**
    元件材料
    */
    
    public Map productProMate() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_stuff=mapper.s_stuff(params);
        result.put("s_stuff", s_stuff);
        
        return result;
    }
    /**
    选择材料
    */
    
    public Map productProMateChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce=mapper.produce(params);
        result.put("produce", produce);
        
        
        SQLList<SQLMap> classid=mapper.classid(params);
        result.put("classid", classid);
        
        
        SQLList<SQLMap> cate=mapper.cate(params);
        SQLMap cate_emt=cate.getExistfirst();
        result.put("cate", cate_emt);
        
        
        SQLList<SQLMap> product_list=mapper.product_list(params);
        result.put("product_list", product_list);
        
        return result;
    }
    /**
    工作环境
    */
    
    public Map productProAmb() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_enment=mapper.s_enment(params);
        SQLMap s_enment_emt=s_enment.getExistfirst();
        result.put("s_enment", s_enment_emt);
        
        return result;
    }
    /**
    生产工艺
    */
    
    public Map productProTech() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> file_admin=mapper.file_admin(params);
        result.put("file_admin", file_admin);
        
        return result;
    }
    /**
    增加文件
    */
    
    public Map productProTechAdd() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> file_list=mapper.file_list(params);
        result.put("file_list", file_list);
        
        return result;
    }
    /**
    国家标准
    */
    
    public Map nationalStandardPre() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        params.def("CMID9",-1);
        Object CMID9 =mapper.CMID9(params);
        result.put("CMID9", CMID9);
        
        
        SQLList<SQLMap> s_file=mapper.s_file(params);
        result.put("s_file", s_file);
        
        
        SQLList<SQLMap> cate=mapper.cate(params);
        SQLMap cate_emt=cate.getExistfirst();
        result.put("cate", cate_emt);
        
        return result;
    }
    /**
    文件版本
    */
    
    public Map fileVersionPre() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_file_version=mapper.s_file_version(params);
        result.put("s_file_version", s_file_version);
        
        return result;
    }
    /**
    引用公共文件
    */
    
    public Map publicDocumentsPre() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> accounts=mapper.accounts(params,pagination);
        accounts.setPagedListInfo(pagination);
        result.put("accounts", accounts);
        
        
        result.put("s_search", pagination.getSearchParas());
        
        return result;
    }
    /**
    工序文件
    */
    
    public Map processDocuments() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMID9",-1);
        Object CMID9 =mapper.CMID9(params);
        result.put("CMID9", CMID9);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_folder=mapper.s_folder(params);
        result.put("s_folder", s_folder);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_file=mapper.s_file(params);
        result.put("s_file", s_file);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_tree_menu=mapper.s_tree_menu(params);
        result.put("s_tree_menu", s_tree_menu);
        
        return result;
    }
    /**
    工序修改文件夹
    */
    
    public Map processUpNewFolder() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_folders=mapper.s_folders(params);
        SQLMap s_folders_emt=s_folders.getExistfirst();
        result.put("s_folders", s_folders_emt);
        
        return result;
    }
    /**
    工序增加版本
    */
    
    public Map processAddVersion() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_file=mapper.s_file(params);
        SQLMap s_file_emt=s_file.getExistfirst();
        result.put("s_file", s_file_emt);
        
        return result;
    }
    /**
    工序文件版本
    */
    
    public Map processVersion() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_file_version=mapper.s_file_version(params);
        result.put("s_file_version", s_file_version);
        
        return result;
    }
    /**
    监控记录
    */
    
    public Map productProMon() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_title=mapper.s_title(params);
        result.put("s_title", s_title);
        
        return result;
    }
    /**
    格式明细
    */
    
    public Map productProMonDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_form=mapper.s_form(params);
        result.put("s_form", s_form);
        
        
        SQLList<SQLMap> s_deploy=mapper.s_deploy(params);
        SQLMap s_deploy_emt=s_deploy.getExistfirst();
        result.put("s_deploy", s_deploy_emt);
        
        return result;
    }
    /**
    选择格式
    */
    
    public Map productProMonChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_mgt=mapper.s_mgt(params);
        result.put("s_mgt", s_mgt);
        
        return result;
    }
    /**
    增加记录数据
    */
    
    public Map addRecordDate() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> form_list=mapper.form_list(params);
        result.put("form_list", form_list);
        
        return result;
    }
    /**
    查看记录
    */
    
    public Map recordDateCheck() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_details=mapper.s_details(params);
        result.put("s_details", s_details);
        
        return result;
    }
    /**
    控件记录
    */
    
    public Map productCon() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> records=mapper.records(params,pagination);
        records.setPagedListInfo(pagination);
        result.put("records", records);
        
        
        SQLList<SQLMap> recordtable=mapper.recordtable(params);
        SQLMap recordtable_emt=recordtable.getExistfirst();
        result.put("recordtable", recordtable_emt);
        
        return result;
    }
    /**
    工作工位
    */
    
    public Map productStation() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_layout=mapper.s_layout(params);
        result.put("s_layout", s_layout);
        
        return result;
    }
    /**
    工位列表
    */
    
    public Map productStationList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> p_work_position=mapper.p_work_position(params,pagination);
        p_work_position.setPagedListInfo(pagination);
        result.put("p_work_position", p_work_position);
        
        return result;
    }
    /**
    工艺文件
    */
    
    public Map productProTechFile() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMSEL","'文档'");
        params.def("CMID9",-1);
        Object CMID9 =mapper.CMID9(params);
        result.put("CMID9", CMID9);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_folder=mapper.s_folder(params);
        result.put("s_folder", s_folder);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_file=mapper.s_file(params);
        result.put("s_file", s_file);
        
        
        SQLList<SQLMap> cate=mapper.cate(params);
        SQLMap cate_emt=cate.getExistfirst();
        result.put("cate", cate_emt);
        
        
        SQLList<SQLMap> s_tree_menu=mapper.s_tree_menu(params);
        result.put("s_tree_menu", s_tree_menu);
        
        return result;
    }
    /**
    文件版本
    */
    
    public Map productProTechFileVersion() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_file_version=mapper.s_file_version(params);
        result.put("s_file_version", s_file_version);
        
        return result;
    }
    /**
    工序工位
    */
    
    public Map productProStation() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        return result;
    }
    /**
    工位选择
    */
    
    public Map productProStationChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_work_position=mapper.s_work_position(params);
        result.put("s_work_position", s_work_position);
        
        
        
        return result;
    }
    /**
    装配节拍
    */
    
    public Map productAssemblingRhythm() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_assembly_able=mapper.s_assembly_able(params);
        SQLMap s_assembly_able_emt=s_assembly_able.getExistfirst();
        result.put("s_assembly_able", s_assembly_able_emt);
        
        return result;
    }
    /**
    质量记录设置
    */
    
    public Map productRecordSet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    更改格式
    */
    
    public Map productRecordSetChange() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record=mapper.s_record(params);
        result.put("s_record", s_record);
        
        return result;
    }
    /**
    更改配置格式
    */
    
    public Map productRecordSetFormtChange() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    查看格式
    */
    
    public Map productRecordSetDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_form=mapper.s_form(params);
        result.put("s_form", s_form);
        
        return result;
    }
    /**
    增加配置
    */
    
    public Map productRecordSetAdd() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_title=mapper.s_title(params);
        result.put("s_title", s_title);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    记录配置
    */
    
    public Map productRecordFormat() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        result.put("s_table", s_table);
        
        return result;
    }
    /**
    格式设置
    */
    
    public Map productRecordFormatSet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_menu=mapper.s_menu(params);
        result.put("s_menu", s_menu);
        
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        result.put("s_table", s_table);
        
        return result;
    }
    /**
    格式明细借鉴
    */
    
    public Map productFormatDraw() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        return result;
    }
    /**
    格式明细
    */
    
    public Map formatDetails() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        return result;
    }
    /**
    修改格式
    */
    
    public Map upFormat() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        return result;
    }
    /**
    格式预览
    */
    
    public Map formatPreview() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        result.put("record_content", TreeTableHelper.viewRecordHtml(getParameter("record_content")));
        
        return result;
    }
    /**
    记录列表
    */
    
    public Map recordLies() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> p_record_work=mapper.p_record_work(params,pagination);
        p_record_work.setPagedListInfo(pagination);
        result.put("p_record_work", p_record_work);
        
        return result;
    }
    /**
    增加记录
    */
    
    public Map addRecord() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        
        SQLList<SQLMap> s_record_list=mapper.s_record_list(params);
        result.put("s_record_list", s_record_list);
        
        return result;
    }
    /**
    记录明细
    */
    
    public Map detsRecord() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        
        SQLList<SQLMap> s_record_work=mapper.s_record_work(params);
        SQLMap s_record_work_emt=s_record_work.getExistfirst();
        result.put("s_record_work", s_record_work_emt);
        
        
        SQLList<SQLMap> record=mapper.record(params);
        result.put("record", record);
        
        
        SQLList<SQLMap> s_record_list=mapper.s_record_list(params);
        result.put("s_record_list", s_record_list);
        
        return result;
    }
    /**
    修改记录
    */
    
    public Map upRecord() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        
        SQLList<SQLMap> s_record_work=mapper.s_record_work(params);
        SQLMap s_record_work_emt=s_record_work.getExistfirst();
        result.put("s_record_work", s_record_work_emt);
        
        
        SQLList<SQLMap> record=mapper.record(params);
        result.put("record", record);
        
        
        SQLList<SQLMap> s_record_list=mapper.s_record_list(params);
        result.put("s_record_list", s_record_list);
        
        return result;
    }
    /**
    合并记录
    */
    
    public Map latticeRecords() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> l_record_work=mapper.l_record_work(params);
        result.put("l_record_work", l_record_work);
        
        
        result.put("record_string", buildTemplate(l_record_work));
        
        return result;
    }
    /**
    评审过程
    */
    
    public Map mVCD23F7F602FF14028A2DAFF9C094632C1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_excel=mapper.s_excel(params,pagination);
        s_excel.setPagedListInfo(pagination);
        result.put("s_excel", s_excel);
        
        return result;
    }
    /**
    增加新的产品工序
    */
    
    public Map productProAdd() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> person_list=mapper.person_list(params);
        result.put("person_list", person_list);
        
        return result;
    }
    /**
    增加检测项目
    */
    
    public Map procedureAdd() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        SQLList<SQLMap> s_nature=mapper.s_nature(params);
        s_nature.setSelectNone("选择性质");
        result.put("s_nature", s_nature);
        
        
        SQLList<SQLMap> s_pr_type=mapper.s_pr_type(params);
        result.put("s_pr_type", s_pr_type);
        
        
        SQLList<SQLMap> person_list=mapper.person_list(params);
        result.put("person_list", person_list);
        
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        
        
        
        
        result.put("pro_produce", create_code(getParameter("CMID5"),"process_barcode"));
        
        
        SQLList<SQLMap> s_no=mapper.s_no(params);
        SQLMap s_no_emt=s_no.getExistfirst();
        result.put("s_no", s_no_emt);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    选择项目性质
    */
    
    public Map productProNatureChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_nature=mapper.s_nature(params);
        result.put("s_nature", s_nature);
        
        return result;
    }
    /**
    选择项目类型
    */
    
    public Map productProTypeChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    选择部件
    */
    
    public Map productProParts() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("category_id",-1);
        SQLList<SQLMap> produce=mapper.produce(params);
        produce.setSelectNone("produce备注");
        result.put("produce", produce);
        
        
        params.def("category_id",-1);
        SQLList<SQLMap> classid=mapper.classid(params);
        classid.setSelectNone("classid备注");
        result.put("classid", classid);
        
        
        params.def("category_id",-1);
        SQLList<SQLMap> cate=mapper.cate(params);
        SQLMap cate_emt=cate.getExistfirst();
        result.put("cate", cate_emt);
        
        
        
        return result;
    }
    /**
    选择标准文件
    */
    
    public Map selectionStandardFile() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        result.put("s_search", pagination.getSearchParas());
        
        
        params.def("CMID9",98);
        Object CMID9 =mapper.CMID9(params);
        result.put("CMID9", CMID9);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_folder=mapper.s_folder(params);
        result.put("s_folder", s_folder);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_files=mapper.s_files(params,pagination);
        s_files.setPagedListInfo(pagination);
        result.put("s_files", s_files);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_tree_menu=mapper.s_tree_menu(params);
        result.put("s_tree_menu", s_tree_menu);
        
        return result;
    }
    /**
    选择岗位
    */
    
    public Map postSelection() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        tb = createTreeBean("s_firm_treecols");
        tb.setPrefix("img");
        SQLList<SQLMap> s_firm=mapper.s_firm(params);
        s_firm = s_firm.buildTree(tb,tb.getPid());
        result.put("s_firm", s_firm);
        
        
        SQLList<SQLMap> s_role=mapper.s_role(params,pagination);
        s_role.setPagedListInfo(pagination);
        result.put("s_role", s_role);
        
        return result;
    }
    /**
    选择工序
    */
    
    public Map productChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pick=mapper.s_pick(params);
        SQLMap s_pick_emt=s_pick.getExistfirst();
        result.put("s_pick", s_pick_emt);
        
        return result;
    }
    /**
    工序列表
    */
    
    public Map productProLists() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    检测项目搜索
    */
    
    public Map procedureSearch() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> person_list=mapper.person_list(params);
        result.put("person_list", person_list);
        
        return result;
    }
    /**
    搜索结果
    */
    
    public Map productProList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("process_user","-1");
        params.def("process_nature","-1");
        params.def("process_type","-1");
        SQLList<SQLMap> s_pro=mapper.s_pro(params);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    工序分类
    */
    
    public Map processClass() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        tb = createTreeBean("s_class_treecols");
        tb.setPrefix("img");
        SQLList<SQLMap> s_class=mapper.s_class(params);
        s_class = s_class.buildTree(tb,tb.getPid());
        result.put("s_class", s_class);
        
        return result;
    }
    /**
    增加子分类
    */
    
    public Map addSonProcessClass() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_class=mapper.t_class(params);
        SQLMap t_class_emt=t_class.getExistfirst();
        result.put("t_class", t_class_emt);
        
        return result;
    }
    /**
    修改分类
    */
    
    public Map upProcessClass() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_class=mapper.t_class(params);
        SQLMap t_class_emt=t_class.getExistfirst();
        result.put("t_class", t_class_emt);
        
        return result;
    }
    /**
    工序性质
    */
    
    public Map processProperty() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_nature=mapper.s_nature(params);
        result.put("s_nature", s_nature);
        
        return result;
    }
    /**
    性质详情
    */
    
    public Map propertyDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_nature=mapper.t_nature(params);
        SQLMap t_nature_emt=t_nature.getExistfirst();
        result.put("t_nature", t_nature_emt);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    修改性质
    */
    
    public Map modifyProperty() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_nature=mapper.t_nature(params);
        SQLMap t_nature_emt=t_nature.getExistfirst();
        result.put("t_nature", t_nature_emt);
        
        return result;
    }
    /**
    工序类型
    */
    
    public Map processType() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    修改工序类型
    */
    
    public Map modifyProcessType() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_type=mapper.t_type(params);
        SQLMap t_type_emt=t_type.getExistfirst();
        result.put("t_type", t_type_emt);
        
        return result;
    }
    /**
    工序颜色
    */
    
    public Map mVC96A9F000C5ED4EC099219A31464E3256() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_nature=mapper.s_nature(params);
        result.put("s_nature", s_nature);
        
        return result;
    }
    public void onvalidate(){
    }
    /**
    */
    
    public Map d_process() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_process(params);
        
        return result;
    }
    /**
    增加工序分类修改
    */
    
    public Map productProcessClassAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_pro_produce_class = mapper.i_pro_produce_class(params);
        result.put("i_pro_produce_class", i_pro_produce_class);
        
        return result;
    }
    /**
    修改信息修改
    */
    
    public Map productProDetUpSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int u_pro = mapper.u_pro(params);
        result.put("u_pro", u_pro);
        
        return result;
    }
    /**
    */
    
    public Map d_pro() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_pro(params);
        
        return result;
    }
    /**
    增加操作人员修改
    */
    
    public Map productProOperAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("pro_user")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_user(params);
        }
        
        return result;
    }
    /**
    修改修改
    */
    
    public Map productProOperUpSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.productProOperUpSubmit(params);
        
        return result;
    }
    /**
    */
    
    public Map d_device() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_device(params);
        
        return result;
    }
    /**
    选择生产设备修改
    */
    
    public Map productProDevChoiceSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int d_pd = mapper.d_pd(params);
        result.put("d_pd", d_pd);
        
        
        for (SQLMap emt:hqlBean.getTableElements("pro_device")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_device(params);
        }
        
        return result;
    }
    /**
    选择检验设备修改
    */
    
    public Map choiceTestingEquipmentSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int d_pd = mapper.d_pd(params);
        result.put("d_pd", d_pd);
        
        
        for (SQLMap emt:hqlBean.getTableElements("pro_device")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_device(params);
        }
        
        return result;
    }
    /**
    选择检验设备备份修改
    */
    
    public Map choiceEquipmentBackupsSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        for (SQLMap emt:hqlBean.getTableElements("pro_device")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_device(params);
        }
        
        return result;
    }
    /**
    选择材料修改
    */
    
    public Map productProMateChoiceSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("pro_stuff")){
            params=new SQLParam(request,emt.getMap());
            mapper.u_product(params);
        }
        
        return result;
    }
    /**
    增加环境修改
    */
    
    public Map productProAmbAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_enment = mapper.i_enment(params);
        result.put("i_enment", i_enment);
        
        return result;
    }
    /**
    */
    
    public Map i_download() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_download = mapper.i_download(params);
        result.put("i_download", i_download);
        
        return result;
    }
    /**
    */
    
    public Map d_file() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_file(params);
        
        return result;
    }
    /**
    增加文件修改
    */
    
    public Map productProTechAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID = mapper.CMID(params);
        result.put("CMID", CMID);
        
        return result;
    }
    /**
    新文件夹修改
    */
    
    public Map newFolderPreSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMID",null);
        params.def("CMID9",-1);
        int i_folder = mapper.i_folder(params);
        result.put("i_folder", i_folder);
        
        return result;
    }
    /**
    引用公共文件修改
    */
    
    public Map publicDocumentsPreSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMID",-1);
        params.def("CMID9",-1);
        int u_project_files_link = mapper.u_project_files_link(params);
        result.put("u_project_files_link", u_project_files_link);
        
        return result;
    }
    /**
    工序新文件夹修改
    */
    
    public Map processNewFolderSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMID",null);
        params.def("CMID9",-1);
        int i_folder = mapper.i_folder(params);
        result.put("i_folder", i_folder);
        
        return result;
    }
    /**
    工序修改文件夹修改
    */
    
    public Map processUpNewFolderSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_folder = mapper.i_folder(params);
        result.put("i_folder", i_folder);
        
        return result;
    }
    /**
    */
    
    public Map d_files_version() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_files_version(params);
        
        return result;
    }
    /**
    格式明细修改
    */
    
    public Map productProMonDetSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID4 = mapper.CMID4(params);
        result.put("CMID4", CMID4);
        
        
        for (SQLMap emt:hqlBean.getTableElements("quality_rowdetail")){
            params=new SQLParam(request,emt.getMap());
            mapper.bi_detail(params);
        }
        
        return result;
    }
    /**
    选择格式修改
    */
    
    public Map productProMonChoiceSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int u_form = mapper.u_form(params);
        result.put("u_form", u_form);
        
        return result;
    }
    /**
    增加格式修改
    */
    
    public Map productProMonAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID2 = mapper.CMID2(params);
        result.put("CMID2", CMID2);
        
        return result;
    }
    /**
    增加行修改
    */
    
    public Map productProMonAddLineSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID2 = mapper.CMID2(params);
        result.put("CMID2", CMID2);
        
        return result;
    }
    /**
    增加记录修改
    */
    
    public Map productProMonAddRecordSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID4 = mapper.CMID4(params);
        result.put("CMID4", CMID4);
        
        return result;
    }
    /**
    增加记录数据修改
    */
    
    public Map addRecordDateSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("quality_details")){
            params=new SQLParam(request,emt.getMap());
            mapper.CMID3(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map d_position() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_position(params);
        
        return result;
    }
    /**
    工位列表修改
    */
    
    public Map productStationListSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_work_position = mapper.i_work_position(params);
        result.put("i_work_position", i_work_position);
        
        return result;
    }
    /**
    增加修改
    */
    
    public Map productSumAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_assembly_able = mapper.i_assembly_able(params);
        result.put("i_assembly_able", i_assembly_able);
        
        return result;
    }
    /**
    更改配置格式修改
    */
    
    public Map productRecordSetFormtChangeSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int d_deploy = mapper.d_deploy(params);
        result.put("d_deploy", d_deploy);
        
        
        for (SQLMap emt:hqlBean.getTableElements("quality_deploy")){
            params=new SQLParam(request,emt.getMap());
            mapper.bi_deploy(params);
        }
        
        return result;
    }
    /**
    增加配置修改
    */
    
    public Map productRecordSetAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_details = mapper.i_details(params);
        result.put("i_details", i_details);
        
        return result;
    }
    /**
    */
    
    public Map u_table() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.u_table(params);
        
        return result;
    }
    /**
    */
    
    public Map d_table() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_table(params);
        
        return result;
    }
    /**
    格式设置修改
    */
    
    public Map productRecordFormatSetSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.productRecordFormatSetSubmit(params);
        
        
        for (SQLMap emt:hqlBean.getTableElements("record_table_map")){
            params=new SQLParam(request,emt.getMap());
            params.def("record_table_sid","-1");
            mapper.b_table_map(params);
        }
        
        return result;
    }
    /**
    上传格式修改
    */
    
    public Map uploadFormatSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDrecord_table_id = mapper.CMIDrecord_table_id(params);
        result.put("CMIDrecord_table_id", CMIDrecord_table_id);
        
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        SQLMap s_table_emt=s_table.getExistfirst();
        result.put("s_table", s_table_emt);
        
        
        TreeTableHelper.saveRecordJsp(context,s_table.getExistfirst().getString("record_content"),s_table.getExistfirst().getString("record_table_sid"),s_table_emt);
        
        return result;
    }
    /**
    */
    
    public Map preview() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        return result;
    }
    /**
    上传格式借鉴修改
    */
    
    public Map referenceUploadFormatSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDrecord_table_id = mapper.CMIDrecord_table_id(params);
        result.put("CMIDrecord_table_id", CMIDrecord_table_id);
        
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        SQLMap s_table_emt=s_table.getExistfirst();
        result.put("s_table", s_table_emt);
        
        
        TreeTableHelper.saveRecordJsp(context,s_table.getExistfirst().getString("record_content"),s_table.getExistfirst().getString("record_table_sid"),s_table_emt);
        
        return result;
    }
    /**
    修改格式修改
    */
    
    public Map upFormatSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.upFormatSubmit(params);
        
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        SQLMap s_table_emt=s_table.getExistfirst();
        result.put("s_table", s_table_emt);
        
        
        TreeTableHelper.saveRecordJsp(context,s_table.getExistfirst().getString("record_content"),s_table.getExistfirst().getString("record_table_sid"),s_table_emt);
        
        return result;
    }
    /**
    */
    
    public Map d_work() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_work(params);
        
        return result;
    }
    /**
    */
    
    public Map onsubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDwork_id = mapper.CMIDwork_id(params);
        result.put("CMIDwork_id", CMIDwork_id);
        
        
        mapper.onsubmit(params);
        
        
        for (SQLMap emt:SQL.foreach(hqlBean.getRecord(),"name","value")){
            params=new SQLParam(request,emt.getMap());
            mapper.b_item_work(params);
        }
        
        
        for (SQLMap emt:FrameHelper.getRecordHQLList(hqlBean,request)){
            params=new SQLParam(request,emt.getMap());
            mapper.b_list_work(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map onInsertFile() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object name =
        mapper.name(params);
        result.put("name", name);
        
        
        PdfUtil.writePdfContext(context,name+".pdf");
        
        return result;
    }
    /**
    修改记录修改
    */
    
    public Map upRecordSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.upRecordSubmit(params);
        
        
        for (SQLMap emt:SQL.foreach(hqlBean.getRecord(),"name","value")){
            params=new SQLParam(request,emt.getMap());
            mapper.b_item_work(params);
        }
        
        
        for (SQLMap emt:FrameHelper.getRecordHQLList(hqlBean,request)){
            params=new SQLParam(request,emt.getMap());
            mapper.b_list_work(params);
        }
        
        return result;
    }
    /**
    */
    
    public String buildTemplate(SQLList l_record_work)  {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        StringBuffer buf=new StringBuffer();
        for (Object obj:l_record_work ){
            SQLMap emt=(SQLMap)obj;
            
            
            result.put("record_work_id", emt.get("record_work_id"));
            
            
            SQLList<SQLMap> s_record_work=mapper.s_record_work(params);
            SQLMap s_record_work_emt=s_record_work.getExistfirst();
            result.put("s_record_work", s_record_work_emt);
            
            
            SQLList<SQLMap> record=mapper.record(params);
            result.put("record", record);
            
            
            buf.append(TemplateUtil.buildTemplate(s_record_work_emt,record,".detail"));
        }
        
        return buf.toString();
    }
    /**
    导入过程修改
    */
    
    public Map mVCBF20C787DD214C1B8859CD1A69DD8B39Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        result.put("json", TreeTableHelper.buildRequirementElementsJson(context,false));
        
        
        int record_id = mapper.record_id(params);
        result.put("record_id", record_id);
        
        
        mapper.mVCBF20C787DD214C1B8859CD1A69DD8B39Submit(params);
        
        return result;
    }
    /**
    增加新的产品工序修改
    */
    
    public Map productProAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID = mapper.CMID(params);
        result.put("CMID", CMID);
        
        return result;
    }
    /**
    增加检测项目修改
    */
    
    public Map procedureAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID = mapper.CMID(params);
        result.put("CMID", CMID);
        
        return result;
    }
    /**
    */
    
    public Map d_class() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_class(params);
        
        return result;
    }
    /**
    增加子分类修改
    */
    
    public Map addSonProcessClassSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int pro_produce_id = mapper.pro_produce_id(params);
        result.put("pro_produce_id", pro_produce_id);
        
        
        mapper.addSonProcessClassSubmit(params);
        
        return result;
    }
    /**
    增加大分类修改
    */
    
    public Map addBigProcessClassSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_class = mapper.i_class(params);
        result.put("i_class", i_class);
        
        return result;
    }
    /**
    修改分类修改
    */
    
    public Map upProcessClassSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.upProcessClassSubmit(params);
        
        return result;
    }
    /**
    */
    
    public Map del_nature() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.del_nature(params);
        
        return result;
    }
    /**
    */
    
    public Map d_type() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_type(params);
        
        return result;
    }
    /**
    增加性质修改
    */
    
    public Map addPropertySubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.addPropertySubmit(params);
        
        return result;
    }
    /**
    修改性质修改
    */
    
    public Map modifyPropertySubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.modifyPropertySubmit(params);
        
        return result;
    }
    /**
    增加工序类型修改
    */
    
    public Map addProcessTypeSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_type = mapper.i_type(params);
        result.put("i_type", i_type);
        
        return result;
    }
    /**
    修改工序类型修改
    */
    
    public Map modifyProcessTypeSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.modifyProcessTypeSubmit(params);
        
        return result;
    }
    /**
    工序颜色修改
    */
    
    public Map mVC96A9F000C5ED4EC099219A31464E3256Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.mVC96A9F000C5ED4EC099219A31464E3256Submit(params);
        }
        
        return result;
    }
    public Map ajaxList(){
        String sql="";
        String pagesql="";
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        if(request.getParameter("cfield_name").contains("process_type")){
            SQLList<SQLMap> process_type=mapper.process_type(params);
            result.put("process_type", process_type);
        }
        
        return result;
    }
    public Map procedureAjax(){
        String sql="";
        String pagesql="";
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        if(request.getParameter("cfield_name").contains("process_type")){
            SQLList<SQLMap> process_type=mapper.process_type(params);
            result.put("process_type", process_type);
        }
        
        return result;
    }
    public String ajaxComplete(){
        String sql="";
        String pagesql="";
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        if(request.getParameter("cfield_name").equals("s_pro_produce")){
            SQLList<SQLMap> s_pro_produce=mapper.s_pro_produce(params);
            request.setAttribute("s_pro_produce", s_pro_produce);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_client_filename")){
            SQLList<SQLMap> s_client_filename=mapper.s_client_filename(params);
            request.setAttribute("s_client_filename", s_client_filename);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_client_name")){
            SQLList<SQLMap> s_client_name=mapper.s_client_name(params);
            request.setAttribute("s_client_name", s_client_name);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_filename")){
            SQLList<SQLMap> s_filename=mapper.s_filename(params);
            request.setAttribute("s_filename", s_filename);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_client_subject")){
            SQLList<SQLMap> s_client_subject=mapper.s_client_subject(params);
            request.setAttribute("s_client_subject", s_client_subject);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_client_filename")){
            SQLList<SQLMap> s_client_filename=mapper.s_client_filename(params);
            request.setAttribute("s_client_filename", s_client_filename);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_client_subject")){
            SQLList<SQLMap> s_client_subject=mapper.s_client_subject(params);
            request.setAttribute("s_client_subject", s_client_subject);
        }
        
        return AJAXCOMPLETE;
    }
}